import { logger } from '../types/constants'

/**
 * 事件处理器类型
 */
type EventHandler = (...args: any[]) => any

/**
 * 事件监听器选项配置
 */
interface EventListenerOptions {
  module?: string // 模块命名空间
  maxCalls?: number // 最大调用次数（自动清理）
  priority?: number // 执行优先级（数字越大优先级越高）
  once?: boolean // 是否只执行一次
  timeout?: number // 执行超时时间（毫秒）
}

/**
 * 事件元数据接口
 */
interface EventMetadata {
  handler: EventHandler // 事件处理函数
  originalHandler: EventHandler // 原始处理函数（用于移除）
  timestamp: number // 事件注册时间戳
  module?: string // 模块命名空间
  maxCalls?: number // 最大调用次数
  callCount: number // 当前调用次数
  priority: number // 执行优先级
  once: boolean // 是否只执行一次
  timeout?: number // 执行超时时间
}

/**
 * 事件触发选项
 */
interface EmitOptions {
  highFrequency?: boolean // 是否高频触发
  skipErrors?: boolean // 是否跳过错误继续执行
  customId?: string // 自定义事件 ID（用于调试）
  queue?: boolean // 是否加入队列处理
  timeout?: number // 执行超时时间（毫秒）
}

/**
 * 频率限制配置
 */
interface RateLimitConfig {
  maxCalls: number // 最大调用次数
  timeWindow: number // 时间窗口（毫秒）
}

/**
 * 事件发射器配置
 */
interface EventEmitterConfig {
  maxListeners?: number // 最大监听器数量
  defaultPriority?: number // 默认优先级
  enableRateLimit?: boolean // 是否启用频率限制
}

/**
 * 事件统计信息接口
 */
interface EventStats {
  listenersCount: number // 监听器数量
  totalTriggers: number // 总触发次数
  firstTriggerTime: number // 首次触发时间
  lastTriggerTime: number // 最后触发时间
  averageInterval: number // 平均触发间隔（毫秒）
  minInterval: number // 最小触发间隔
  maxInterval: number // 最大触发间隔
  triggerHistory: number[] // 触发时间戳历史（用于计算频率）
  recentTriggers: number // 最近1分钟触发次数
  maxTriggersPerMinute: number // 最大触发频率（次/分钟）
  successCount: number // 成功处理次数
  errorCount: number // 处理失败次数
  lastError?: Error // 最后错误信息
  frequency: number // 触发频率（次/分钟）
  health: 'excellent' | 'good' | 'warning' | 'critical' | 'stopped' // 健康状态
}

/**
 * 统计报表接口
 */
interface EventStatsReport {
  summary: {
    totalEvents: number
    totalTriggers: number
    totalSuccess: number
    totalErrors: number
    overallSuccessRate: number
    startTime: number
    endTime: number
  }
  topEvents: Array<{
    event: string
    triggers: number
    successRate: number
    frequency: number
    health: string
  }>
  recentActivity: Array<{
    event: string
    timestamp: number
    success: boolean
    listeners: number
  }>
  warnings: string[]
}

/**
 * 事件发射器 ：用于管理和触发自定义事件
 */
export class EventEmitter {
  readonly name: string = 'EventEmitter'
  private static instance: EventEmitter
  private events: Map<string, EventMetadata[]> = new Map()
  private maxListeners: number
  private rateLimits: Map<string, RateLimitConfig> = new Map()
  private callHistory: Map<string, number[]> = new Map()
  private readonly defaultPriority: number = 0

  // 事件队列
  private QUEUE_TIMEOUT: number = 30000
  private processingEvents: Set<string> = new Set()
  private eventQueue: Map<string, Array<{
    args: any[]
    options: EmitOptions
    resolve: (value: boolean) => void
    reject: (error: Error) => void
  }>> = new Map()

  // 事件统计
  private eventStats: Map<string, EventStats> = new Map()
  private readonly MAX_HISTORY_SIZE = 1000 // 最大历史记录数量

  private constructor(config: EventEmitterConfig = {}) {
    this.maxListeners = config.maxListeners || 100
    this.defaultPriority = config.defaultPriority || 0

    logger.debug(`[${this.name}] 事件发射器初始化完成`, {
      maxListeners: this.maxListeners,
      defaultPriority: this.defaultPriority,
    })
  }

  /**
   * 获取单例实例
   */
  static getInstance(config?: EventEmitterConfig): EventEmitter {
    if (!EventEmitter.instance) {
      EventEmitter.instance = new EventEmitter(config)
    }
    return EventEmitter.instance
  }

  /**
   * 设置最大监听器数量
   */
  setMaxListeners(maxListeners: number): void {
    if (maxListeners <= 0)
      throw new Error(`[${this.name}] 最大监听器数量必须大于0`)

    const oldMax = this.maxListeners
    this.maxListeners = maxListeners

    logger.debug(`[${this.name}] 更新最大监听器数量`, {
      oldMax,
      newMax: maxListeners,
    })
  }

  /**
   * 获取当前最大监听器数量
   */
  getMaxListeners(): number {
    return this.maxListeners
  }

  /**
   * 获取当前活跃监听器数量
   */
  getListenerCount(event?: string): number {
    if (event) {
      const namespacedEvent = this.getNamespacedEvent(event)
      return this.events.get(namespacedEvent)?.length || 0
    }

    let total = 0
    this.events.forEach((listeners) => {
      total += listeners.length
    })
    return total
  }

  /**
   * 注册事件监听器
   * @param event - 事件名称
   * @param handler - 事件处理函数
   * @param options - 可选的模块名（如果event未包含命名空间）
   */
  on(event: string, handler: EventHandler, options?: EventListenerOptions): () => void {
    const {
      module,
      maxCalls,
      priority = this.defaultPriority,
      once = false,
      timeout,
    } = options || {}

    const namespacedEvent = this.getNamespacedEvent(event, module)
    const listeners = this.events.get(namespacedEvent) || []

    // 检查监听器数量限制
    if (listeners.length >= this.maxListeners) {
      throw new Error(
        `[${this.name}] 事件 "${namespacedEvent}" 的监听器数量超过限制 (${this.maxListeners})`,
      )
    }

    // 包装处理函数，支持自动清理和超时
    const wrappedHandler = this.wrapEventHandler(handler, namespacedEvent, timeout)

    const metadata: EventMetadata = {
      handler: wrappedHandler,
      originalHandler: handler,
      timestamp: Date.now(),
      module: module || this.parseModuleFromEvent(event),
      maxCalls,
      callCount: 0,
      priority,
      once,
      timeout,
    }

    if (!this.events.has(namespacedEvent))
      this.events.set(namespacedEvent, [])

    // 按优先级插入（优先级高的在前面）
    const eventListeners = this.events.get(namespacedEvent)!
    const insertIndex = eventListeners.findIndex(
      listener => listener.priority < priority,
    )

    if (insertIndex === -1) {
      eventListeners.push(metadata)
    }
    else {
      eventListeners.splice(insertIndex, 0, metadata)
    }

    logger.debug(`[${this.name}] 注册事件监听: ${namespacedEvent}`, {
      priority,
      once,
      maxCalls,
      totalListeners: eventListeners.length,
    })

    // 返回取消监听函数
    return () => {
      this.off(event, { handler })
      logger.debug(`[${this.name}] 已移除事件监听: ${namespacedEvent}`)
    }
  }

  /**
   * 注册一次性事件监听器
   * @param event - 事件名称
   * @param handler - 事件处理函数
   * @param options - 监听器选项（不含once）
   * @returns {Function} 取消监听的函数
   */
  once(event: string, handler: EventHandler, options: Omit<EventListenerOptions, 'once'> = {}): () => void {
    return this.on(event, handler, { ...options, once: true })
  }

  /**
   * 移除事件监听器
   */
  off(event: string, options?: { handler?: EventHandler, module?: string }): boolean {
    const { handler, module } = options || {}
    const namespacedEvent = this.getNamespacedEvent(event, module)

    if (!this.events.has(namespacedEvent)) {
      logger.warn(`[${this.name}] 尝试移除不存在的事件监听: ${namespacedEvent}`)
      return false
    }

    if (!handler) {
      // 移除所有处理函数
      this.events.delete(namespacedEvent)
      return true
    }

    // 移除特定的处理函数
    const listeners = this.events.get(namespacedEvent)!
    // 移除特定的处理函数
    const originalIndex = listeners.findIndex(
      meta => meta.originalHandler === handler,
    )

    if (originalIndex === -1) {
      logger.warn(`[${this.name}] 未找到要移除的事件处理函数: ${namespacedEvent}`)
      return false
    }

    listeners.splice(originalIndex, 1)
    logger.debug(`[${this.name}] 移除事件监听器: ${namespacedEvent}`)

    if (listeners.length === 0) {
      this.events.delete(namespacedEvent)
    }

    return true
  }

  /**
   * 触发事件
   * @param event - 事件名称
   * @param module - 模块名（如果 event 未包含命名空间）
   * @param args - 传递给处理函数的参数
   */
  emit(event: string, module?: string, ...args: any[]): boolean
  emit(event: string, module: string, options: EmitOptions, ...args: any[]): boolean
  emit(event: string, module?: string, ...params: any[]): boolean {
    // 重载参数处理
    let options: EmitOptions = {}
    let actualArgs: any[]

    if (params.length > 0 && typeof params[0] === 'object' && 'highFrequency' in params[0]) {
      options = params[0] as EmitOptions
      actualArgs = params.slice(1)
    }
    else {
      actualArgs = params
    }

    const namespacedEvent = this.getNamespacedEvent(event, module)

    // 如果启用了队列且当前正在处理相同事件，加入队列
    if (options.queue !== false && this.processingEvents.has(namespacedEvent)) {
      this.emitAsync(namespacedEvent, actualArgs, options).catch((error: any) => {
        logger.error(`[${this.name}] 异步事件处理失败: ${namespacedEvent}`, error)
      })
      return true // 返回 true 表示事件已接受
    }

    // 立即执行，并在完成后处理队列
    return this.emitInternal(namespacedEvent, actualArgs, options)
  }

  /**
   * 异步触发事件（支持队列处理）
   */
  async emitAsync(eventName: string, args: any[], options: EmitOptions = {}): Promise<boolean> {
    return new Promise((resolve, reject) => {
      const { queue = true, timeout = this.QUEUE_TIMEOUT, ...emitOptions } = options

      // 如果不使用队列或当前没有在处理相同事件，直接执行
      if (!queue || !this.processingEvents.has(eventName)) {
        this.processEventImmediately(eventName, args, emitOptions, resolve, reject)
        return
      }

      // 添加到队列
      this.enqueueEvent(eventName, args, emitOptions, resolve, reject, timeout)
    })
  }

  /**
   * 立即处理事件
   */
  private processEventImmediately(
    eventName: string,
    args: any[],
    options: EmitOptions,
    resolve: (value: boolean) => void,
    reject: (error: Error) => void,
  ): void {
    try {
      const result = this.emitInternal(eventName, args, options)
      resolve(result)
    }
    catch (error) {
      reject(error as Error)
    }
  }

  /**
   * 内部事件处理逻辑
   */
  private emitInternal(eventName: string, args: any[], options: EmitOptions = {}): boolean {
    const { highFrequency = false, skipErrors = false, customId } = options
    const eventId = customId || eventName
    const listeners = this.events.get(eventName) || []

    // 记录事件触发开始
    let hasActiveListeners = false
    let hasError = false
    let lastError: Error | undefined

    try {
      // 检查频率限制
      if (!this.checkRateLimit(eventName)) {
        logger.warn(`[${this.name}] 事件触发频率限制: ${eventName}`)
        return false
      }

      logger.debug(`[${this.name}] 触发事件: ${eventName} (ID: ${eventId})`, {
        listeners: listeners.length,
        highFrequency,
        args,
      })

      const listenersToRemove: number[] = []

      if (highFrequency) {
        // 高频模式：使用 for 循环优化性能
        for (let i = 0; i < listeners.length; i++) {
          const metadata = listeners[i]

          if (this.executeListener(metadata, args, eventId, skipErrors)) {
            hasActiveListeners = true

            // 检查是否需要移除（once 或 maxCalls 达到）
            if (metadata.once || (metadata.maxCalls && metadata.callCount >= metadata.maxCalls)) {
              listenersToRemove.push(i)
            }
          }
        }
      }
      else {
        // 默认模式：使用 forEach（代码更可读）
        listeners.forEach((metadata, index) => {
          if (this.executeListener(metadata, args, eventId, skipErrors)) {
            hasActiveListeners = true

            if (metadata.once || (metadata.maxCalls && metadata.callCount >= metadata.maxCalls)) {
              listenersToRemove.push(index)
            }
          }
        })
      }

      // 移除需要清理的监听器
      if (listenersToRemove.length > 0) {
        this.removeListenersByIndex(eventName, listenersToRemove)
      }

      // 处理队列中的下一个事件（如果当前事件处理完成）
      if (this.eventQueue.has(eventName) && this.eventQueue.get(eventName)!.length > 0) {
        setTimeout(() => this.processNextInQueue(eventName), 0)
      }
    }
    catch (error) {
      hasError = true
      lastError = error as Error
      // 记录错误触发
      this.recordEventTrigger(eventName, false, lastError)
      throw error
    }
    finally {
      // 确保统计记录
      if (!hasError) {
        this.recordEventTrigger(eventName, true)
      }
    }

    return hasActiveListeners
  }

  /**
   * 包装事件处理函数（支持超时和调用计数）
   */
  private wrapEventHandler(
    handler: EventHandler,
    eventName: string,
    timeout?: number,
  ): EventHandler {
    return (...args: any[]) => {
      if (timeout) {
        // 支持超时控制
        return new Promise((resolve, reject) => {
          const timeoutId = setTimeout(() => {
            reject(new Error(`⏰ 事件处理超时: ${eventName} (${timeout}ms)`))
          }, timeout)

          try {
            const result: any = handler(...args)
            clearTimeout(timeoutId)

            if (result && typeof result.then === 'function' && typeof result.catch === 'function') {
              result.then(resolve).catch(reject)
            }
            else {
              resolve(result)
            }
          }
          catch (error) {
            clearTimeout(timeoutId)
            reject(error)
          }
        })
      }
      else {
        return handler(...args)
      }
    }
  }

  /**
   * 将事件加入队列
   */
  private enqueueEvent(
    eventName: string,
    args: any[],
    options: EmitOptions,
    resolve: (value: boolean) => void,
    reject: (error: Error) => void,
    timeout: number,
  ): void {
    if (!this.eventQueue.has(eventName))
      this.eventQueue.set(eventName, [])

    const queue = this.eventQueue.get(eventName)!
    const queueItem = { args, options, resolve, reject }

    // 添加超时处理
    const timeoutId = setTimeout(() => {
      const index = queue.findIndex(item => item.resolve === resolve)
      if (index > -1) {
        queue.splice(index, 1)
        reject(new Error(`事件处理超时: ${eventName} (${timeout}ms)`))
      }
    }, timeout)

    // 修改 resolve/reject 以清理超时
    const originalResolve = resolve
    const originalReject = reject

    queueItem.resolve = (value: boolean) => {
      clearTimeout(timeoutId)
      originalResolve(value)
    }

    queueItem.reject = (error: Error) => {
      clearTimeout(timeoutId)
      originalReject(error)
    }

    queue.push(queueItem)

    logger.debug(`[${this.name}] 事件加入队列: ${eventName}`, {
      queueSize: queue.length,
      currentProcessing: this.processingEvents.has(eventName),
    })
  }

  /**
   * 处理队列中的下一个事件
   */
  private async processNextInQueue(eventName: string): Promise<void> {
    const queue = this.eventQueue.get(eventName)
    if (!queue || queue.length === 0) {
      this.processingEvents.delete(eventName)
      return
    }

    // 标记为正在处理
    this.processingEvents.add(eventName)

    // 取出队列中的第一个事件
    const queueItem = queue.shift()!
    const { args, options, resolve, reject } = queueItem

    try {
      logger.debug(`[${this.name}] 处理队列事件: ${eventName}`, {
        remainingInQueue: queue.length,
      })

      const result = this.emitInternal(eventName, args, options)
      resolve(result)
    }
    catch (error) {
      reject(error as Error)
    }
    finally {
      // 处理队列中的下一个事件
      setTimeout(() => this.processNextInQueue(eventName), 0)
    }
  }

  /**
   * 记录事件触发
   */
  private recordEventTrigger(eventName: string, success: boolean = true, error?: Error): void {
    const now = Date.now()
    const listeners = this.events.get(eventName) || []

    if (!this.eventStats.has(eventName)) {
      this.eventStats.set(eventName, this.createEmptyStats())
    }

    const stats = this.eventStats.get(eventName)!
    const previousTotalTriggers = stats.totalTriggers
    const previousTriggerTime = stats.lastTriggerTime

    // 更新监听器数量
    stats.listenersCount = listeners.length

    // 更新触发总次数
    stats.totalTriggers++

    // 更新最后触发时间
    stats.lastTriggerTime = now

    // 计算触发间隔
    if (previousTriggerTime > 0) {
      const interval = now - previousTriggerTime
      stats.averageInterval = Number(((stats.averageInterval * Math.max(previousTotalTriggers - 1, 0) + interval) / previousTotalTriggers).toFixed(2))
      stats.minInterval = Math.min(stats.minInterval, interval)
      stats.maxInterval = Math.max(stats.maxInterval, interval)
    }

    // 记录触发时间并限制历史记录大小
    stats.triggerHistory.push(now)
    if (stats.triggerHistory.length > this.MAX_HISTORY_SIZE) {
      stats.triggerHistory = stats.triggerHistory.slice(-this.MAX_HISTORY_SIZE)
    }

    // 计算最近触发频率
    stats.recentTriggers = this.calculateRecentTriggers(stats.triggerHistory, 60000)
    stats.maxTriggersPerMinute = Math.max(stats.maxTriggersPerMinute, stats.recentTriggers)

    // 更新成功/失败计数
    if (success) {
      stats.successCount++
    }
    else {
      stats.errorCount++
      stats.lastError = error
    }

    // 计算健康状态
    stats.health = this.calculateHealthStatus(stats)
  }

  /**
   * 计算最近触发次数
   */
  private calculateRecentTriggers(history: number[], timeWindow: number): number {
    const now = Date.now()
    return history.filter(time => now - time <= timeWindow).length
  }

  /**
   * 计算健康状态
   */
  private calculateHealthStatus(stats: EventStats): EventStats['health'] {
    const errorRate = stats.errorCount / stats.totalTriggers

    if (errorRate > 0.5)
      return 'critical'
    if (errorRate > 0.2)
      return 'warning'
    if (stats.listenersCount === 0 && stats.totalTriggers > 0)
      return 'stopped'
    if (stats.recentTriggers > 50)
      return 'warning' // 频率过高

    return stats.totalTriggers === 0 ? 'excellent' : 'good'
  }

  /**
   * 设置事件频率限制
   * @param {string} event - 事件名称
   * @param {number} maxCalls - 最大调用次数
   * @param {number} timeWindow - 时间窗口（毫秒）
   */
  setRateLimit(event: string, maxCalls: number, timeWindow: number): void {
    const namespacedEvent = this.getNamespacedEvent(event)
    this.rateLimits.set(namespacedEvent, { maxCalls, timeWindow })

    logger.debug(`⏱️ 设置频率限制: ${namespacedEvent} - ${maxCalls}次/${timeWindow}ms`)
  }

  /**
   * 检查频率限制
   */
  private checkRateLimit(eventName: string): boolean {
    const config = this.rateLimits.get(eventName)
    if (!config)
      return true

    const now = Date.now()
    const history = this.callHistory.get(eventName) || []

    // 清理过期记录
    const validHistory = history.filter(time => now - time < config.timeWindow)
    validHistory.push(now)

    this.callHistory.set(eventName, validHistory)

    return validHistory.length <= config.maxCalls
  }

  /**
   * 执行单个监听器
   */
  private executeListener(
    metadata: EventMetadata,
    args: any[],
    eventId: string,
    skipErrors: boolean,
  ): boolean {
    try {
      metadata.callCount++
      metadata.handler(...args)

      logger.debug(`[${this.name}] 事件处理成功: ${eventId}`, {
        callCount: metadata.callCount,
        maxCalls: metadata.maxCalls,
      })

      return true
    }
    catch (error) {
      logger.error(`[${this.name}] 事件处理错误: ${eventId}`, error)

      if (!skipErrors) {
        throw error
      }
      return false
    }
  }

  /**
   * 按索引移除监听器
   */
  private removeListenersByIndex(eventName: string, indices: number[]): void {
    const listeners = this.events.get(eventName)
    if (!listeners)
      return

    // 从大到小排序索引，避免删除时索引变化
    indices.sort((a, b) => b - a).forEach((index) => {
      listeners.splice(index, 1)
    })

    if (listeners.length === 0) {
      this.events.delete(eventName)
    }

    logger.debug(`[${this.name}] 自动清理 ${indices.length} 个事件监听器: ${eventName}`)
  }

  /**
   * 获取所有已注册事件（带元数据）
   * @returns 事件名称 -> 监听器元数据的映射
   */
  getAllEvents(): Record<string, EventMetadata[]> {
    return Object.fromEntries(this.events.entries())
  }

  /**
   * 获取特定事件的所有监听器
   * @param event - 事件名称
   * @returns 监听器元数据数组（按注册时间排序）
   */
  getListeners(event: string): EventMetadata[] {
    const namespacedEvent = this.getNamespacedEvent(event)
    return this.events.get(namespacedEvent)?.slice() || []
  }

  /**
   * 获取事件统计信息
   */
  getEventStats(event?: string): EventStats | Record<string, EventStats> {
    if (event) {
      const eventName = this.getNamespacedEvent(event)
      const stats = this.eventStats.get(eventName) || this.createEmptyStats()

      //  直接添加频率计算
      stats.frequency = Number(this.getEventFrequency(eventName).toFixed(2))
      return stats
    }

    //  获取所有事件的统计信息并添加频率
    const allStats: Record<string, EventStats> = {}

    this.events.forEach((_, eventName) => {
      const stats = this.eventStats.get(eventName) || this.createEmptyStats()

      //  添加频率计算
      stats.frequency = Number(this.getEventFrequency(eventName).toFixed(2))
      allStats[eventName] = stats
    })

    return allStats
  }

  /**
   * 生成统计报表
   */
  generateStatsReport(timeRange: number = 24 * 60 * 60 * 1000): EventStatsReport {
    const now = Date.now()
    const startTime = now - timeRange
    const report: EventStatsReport = {
      summary: {
        totalEvents: 0,
        totalTriggers: 0,
        totalSuccess: 0,
        totalErrors: 0,
        overallSuccessRate: 0,
        startTime,
        endTime: now,
      },
      topEvents: [],
      recentActivity: [],
      warnings: [],
    }

    let totalTriggers = 0
    let totalSuccess = 0
    let totalErrors = 0

    // 分析每个事件的统计信息
    this.eventStats.forEach((stats, eventName) => {
      const successRate = stats.totalTriggers > 0 ? stats.successCount / stats.totalTriggers : 1

      totalTriggers += stats.totalTriggers
      totalSuccess += stats.successCount
      totalErrors += stats.errorCount

      // 添加到热门事件列表
      report.topEvents.push({
        event: eventName,
        triggers: stats.totalTriggers,
        successRate,
        frequency: this.getEventFrequency(eventName, 60000),
        health: stats.health,
      })

      // 检查警告条件
      if (stats.health === 'critical') {
        report.warnings.push(`事件 "${eventName}" 健康状态为严重，错误率: ${(stats.errorCount / stats.totalTriggers * 100).toFixed(1)}%`)
      }
      else if (stats.health === 'warning') {
        report.warnings.push(`事件 "${eventName}" 健康状态为警告，请检查`)
      }

      // 添加最近活动
      if (stats.triggerHistory.length > 0) {
        const lastTrigger = stats.triggerHistory[stats.triggerHistory.length - 1]
        if (lastTrigger >= startTime) {
          report.recentActivity.push({
            event: eventName,
            timestamp: lastTrigger,
            success: stats.errorCount === 0 || stats.successCount > stats.errorCount,
            listeners: stats.listenersCount,
          })
        }
      }
    })

    // 排序热门事件
    report.topEvents.sort((a, b) => b.triggers - a.triggers)
    report.topEvents = report.topEvents.slice(0, 10) // 取前10名

    // 排序最近活动
    report.recentActivity.sort((a, b) => b.timestamp - a.timestamp)
    report.recentActivity = report.recentActivity.slice(0, 20) // 取最近20条

    // 更新汇总信息
    report.summary = {
      totalEvents: this.eventStats.size,
      totalTriggers,
      totalSuccess,
      totalErrors,
      overallSuccessRate: totalTriggers > 0 ? totalSuccess / totalTriggers : 0,
      startTime,
      endTime: now,
    }

    return report
  }

  /**
   * 获取事件触发频率（次/分钟）
   */
  getEventFrequency(event: string, timeWindow: number = 60000): number {
    const eventName = this.getNamespacedEvent(event)
    const stats = this.eventStats.get(eventName)

    if (!stats)
      return 0

    const now = Date.now()
    const recentTriggers = stats.triggerHistory.filter(time => now - time <= timeWindow)

    return (recentTriggers.length / timeWindow) * 60000 // 转换为次/分钟
  }

  /**
   * 创建空统计信息
   */
  private createEmptyStats(): EventStats {
    const now = Date.now()

    return {
      listenersCount: 0,
      totalTriggers: 0,
      firstTriggerTime: now,
      lastTriggerTime: 0,
      averageInterval: 0,
      minInterval: Infinity,
      maxInterval: 0,
      maxTriggersPerMinute: 0,
      recentTriggers: 0,
      triggerHistory: [],
      successCount: 0,
      errorCount: 0,
      frequency: 0,
      health: 'excellent',
    }
  }

  /**
   * 获取事件统计信息
   * @param {string} event - 事件名称（可选，不传则返回所有）
   * @returns {object} 统计信息
   */
  getStats(event?: string): {
    totalEvents: number
    totalListeners: number
    events: Record<string, { listeners: number, module?: string }>
  } {
    if (event) {
      const namespacedEvent = this.getNamespacedEvent(event)
      const listeners = this.events.get(namespacedEvent) || []
      return {
        totalEvents: 1,
        totalListeners: listeners.length,
        events: {
          [namespacedEvent]: {
            listeners: listeners.length,
            module: listeners[0]?.module,
          },
        },
      }
    }

    let totalListeners = 0
    const events: Record<string, { listeners: number, module?: string }> = {}

    this.events.forEach((listeners, eventName) => {
      events[eventName] = {
        listeners: listeners.length,
        module: listeners[0]?.module,
      }
      totalListeners += listeners.length
    })

    return {
      totalEvents: this.events.size,
      totalListeners,
      events,
    }
  }

  /**
   * 清空事件统计
   */
  clearEventStats(event?: string): void {
    if (event) {
      const eventName = this.getNamespacedEvent(event)
      this.eventStats.delete(eventName)
      logger.debug(`[${this.name}] 清空事件统计: ${eventName}`)
    }
    else {
      this.eventStats.clear()
      logger.debug(`[${this.name}] 清空所有事件统计`)
    }
  }

  /**
   * 清除所有事件监听器
   * @param module - 模块名称（可选，只清除指定模块）
   */
  clearAll(module?: string): void {
    if (module) {
      // 清除指定模块的事件
      let removedCount = 0
      this.events.forEach((listeners, eventName) => {
        const filtered = listeners.filter(meta => meta.module !== module)
        if (filtered.length === 0) {
          this.events.delete(eventName)
          removedCount++
        }
        else if (filtered.length < listeners.length) {
          this.events.set(eventName, filtered)
          removedCount += listeners.length - filtered.length
        }
      })
      logger.debug(`[${this.name}] 清除模块 "${module}" 的事件监听器，移除 ${removedCount} 个`)
    }
    else {
      // 清除所有事件
      const totalCount = this.events.size
      this.events.clear()
      this.callHistory.clear()
      logger.debug(`[${this.name}] 清除所有事件监听器，共 ${totalCount} 个事件`)
    }

    this.clearEventStats()
  }

  /**
   * 获取带命名空间的事件名
   */
  private getNamespacedEvent(event: string, module?: string): string {
    if (event.includes(':'))
      return event // 已包含命名空间

    return `${module || 'global'}:${event}` // 默认全局命名空间
  }

  /**
   * 从事件名解析模块名
   */
  private parseModuleFromEvent(event: string): string | undefined {
    const parts = event.split(':')
    return parts.length > 1 ? parts[0] : undefined
  }
}
